home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / a_utils / lgrammar / src / load.c < prev    next >
C/C++ Source or Header  |  1993-09-09  |  12KB  |  520 lines
  1. /*************************************************************************/
  2. /*
  3.  *
  4.  *  Filename:  load.c
  5.  *
  6.  */
  7.  
  8. #include "grammar.h"
  9. #include <dirent.h>
  10. #include <sys/param.h>
  11. #include <sys/types.h>
  12. #include <sys/stat.h>
  13.  
  14. #include <malloc.h>
  15. #include <math.h>
  16. #include <stdio.h>
  17.  
  18. #include <X11/Intrinsic.h>
  19. #include <X11/StringDefs.h>
  20. #include <X11/Shell.h>
  21. #include <X11/Xaw/AsciiText.h>
  22. #include <X11/Xaw/Box.h>
  23. #include <X11/Xaw/Cardinals.h>
  24. #include <X11/Xaw/Command.h>
  25. #include <X11/Xaw/Dialog.h>
  26. #include <X11/Xaw/Form.h>
  27. #include <X11/Xaw/Label.h>
  28. #include <X11/Xaw/List.h>
  29. #include <X11/Xaw/Paned.h>
  30. #include <X11/Xaw/Text.h>
  31. #include <X11/Xaw/Viewport.h>
  32.  
  33.  
  34. /* aus xui.c */
  35.  
  36. extern Widget g_posx, g_posy, g_posz;
  37. extern Widget g_angle, g_length, g_scale;
  38. extern Widget g_headx, g_heady, g_headz;
  39. extern Widget g_leftx, g_lefty, g_leftz;
  40. extern Widget g_upx, g_upy, g_upz;
  41. extern Widget proj_x0, proj_y0, proj_a;
  42. extern Widget gram;
  43.  
  44. extern int persp_x0, persp_y0, persp_a;
  45.  
  46. extern XtAppContext app_context;
  47.  
  48. /* functions in load.c:
  49.  *
  50.  * void Load();
  51.  * void update_filelist();
  52.  * void ClickList();
  53.  * void LoadOk();
  54.  * void LoadCancel();
  55.  *
  56.  */ 
  57.  
  58.  
  59. Widget filelist, text;
  60.  
  61. char workdir[MAXPATHLEN];
  62.  
  63. int countclick; 
  64.  
  65. /*************************************************************************/
  66. /* Function Name: Load
  67.  * Description: 
  68.  * Arguments: 
  69.  * Globals: filelist, text, workdir
  70.  */
  71.  
  72. /* ARGSUSED */
  73. void Load(w, client_data, call_data)
  74. Widget w;
  75. XtPointer client_data, call_data;
  76. {
  77.   Widget popup, pform, viewport, l_ok, l_cancel;
  78.  
  79.   void ClickList();
  80.   void update_filelist();
  81.   void LoadOk();
  82.   void LoadCancel();
  83.  
  84.   static int counter = 0;
  85.  
  86.   popup = XtVaCreatePopupShell("popup", topLevelShellWidgetClass, w,
  87.                      NULL);
  88.  
  89.   pform = XtVaCreateManagedWidget("pform", formWidgetClass, popup, NULL);
  90.  
  91.   text = XtVaCreateManagedWidget("text", asciiTextWidgetClass, pform,
  92.                                  XtNeditType, XawtextEdit,
  93.                                  XtNwidth, 250,
  94.                                  XtNheight, 30,
  95.                                  XtNautoFill, TRUE,
  96.                                  NULL);
  97.  
  98.   if (counter == 0)
  99.   {
  100.     getwd(workdir);
  101.     if (workdir == NULL)
  102.     {
  103.       printf("getwd\n");
  104.       exit(1);
  105.     }
  106.     counter++;
  107.   }
  108.   
  109.   XtVaSetValues(text, XtNstring, workdir, NULL);
  110.  
  111.  
  112.   viewport = XtVaCreateManagedWidget("viewport", viewportWidgetClass, pform,
  113.                                      XtNfromVert, text,
  114.                                      XtNallowHoriz, TRUE,
  115.                                      XtNallowVert, TRUE,
  116.                                      XtNheight, 250,
  117.                                      XtNwidth, 150,
  118.                                      NULL);
  119.  
  120.   filelist = XtVaCreateManagedWidget("filelist", listWidgetClass, viewport,
  121.                                      XtNdefaultColumns,1,
  122.                                      NULL);
  123.  
  124.   XtAddCallback(filelist, XtNcallback, ClickList, NULL);
  125.  
  126.   countclick = 0;
  127.   update_filelist();
  128.  
  129.   l_ok = XtVaCreateManagedWidget("O.K.", commandWidgetClass, pform,
  130.                                  XtNfromHoriz, viewport,
  131.                                  XtNfromVert, text,
  132.                                  NULL);
  133.   XtAddCallback(l_ok, XtNcallback, LoadOk, NULL); 
  134.  
  135.   l_cancel = XtVaCreateManagedWidget("Cancel", commandWidgetClass, pform,
  136.                                      XtNfromHoriz, viewport,
  137.                                      XtNfromVert, l_ok,
  138.                                      NULL);
  139.   XtAddCallback(l_cancel, XtNcallback, LoadCancel, NULL);
  140.  
  141.   XtPopup(popup, XtGrabNonexclusive);
  142. }
  143.  
  144. /*************************************************************************/
  145. /* Function Name: update_filelist
  146.  * Description: 
  147.  * Arguments: 
  148.  * Globals: workdir, filelist
  149.  */
  150.  
  151. void update_filelist()
  152. {
  153.   DIR  *directory;
  154.   struct dirent *dp;
  155.  
  156.   int entry;
  157.   String *str;
  158.   int i;   /* Schleifenvariable */
  159.  
  160.  
  161.   directory = (DIR *)malloc(sizeof(DIR));
  162.   if (directory == NULL)
  163.   {
  164.     fprintf(stderr, "Kein Speicher mehr frei!\n");
  165.     fprintf(stderr, "malloc-Aufruf in update_filelist\n");
  166.     exit(1);
  167.   }
  168.  
  169.   directory = opendir(workdir);
  170.   if (directory == NULL)
  171.   {
  172.     fprintf(stderr, "Fehler bei opendir1 in update_filelist\n");
  173.     exit(1);
  174.   }
  175.   entry = 0;
  176.  
  177.   dp = (struct dirent *)malloc(sizeof(struct dirent));
  178.   if (dp == NULL)
  179.   {
  180.     fprintf(stderr, "Kein Speicher mehr frei!\n");
  181.     fprintf(stderr, "malloc-Aufruf in update_filelist\n");
  182.     exit(1);
  183.   }
  184.  
  185.   for (dp = readdir(directory); dp != NULL; dp = readdir(directory))
  186.   {
  187.     entry++;
  188.   }
  189.   closedir(directory);
  190.  
  191.   str = (String *)malloc(sizeof(String) * entry);
  192.   if (str == NULL)
  193.   {
  194.     fprintf(stderr, "Kein Speicher mehr frei!\n");
  195.     fprintf(stderr, "malloc-Aufruf in update_filelist\n");
  196.     exit(1);
  197.   }
  198.  
  199.   directory = opendir(workdir);
  200.   if (directory == NULL)
  201.   {
  202.     fprintf(stderr, "Fehler bei opendir2 in update_filelist\n");
  203.     exit(1);
  204.   }
  205.   dp = readdir(directory);  /* Eintrag .  */
  206.  
  207.   i = 0;
  208.   for (dp = readdir(directory); dp != NULL; dp = readdir(directory))
  209.   {
  210.     str[i] = XtNewString(dp->d_name);
  211.     i++;
  212.   } 
  213.   XawListChange(filelist, str, i, 0, TRUE);
  214.   closedir(directory);
  215. }
  216.  
  217. /*************************************************************************/
  218. /* Function Name: ClickList
  219.  * Description: 
  220.  * Arguments: 
  221.  * Globals: text, workdir
  222.  */
  223.  
  224. /*ARGSUSED*/
  225. void ClickList(w, client_data, call_data)
  226. Widget w;
  227. XtPointer client_data, call_data;
  228. {
  229.   XawListReturnStruct *listitem = (XawListReturnStruct *)call_data;
  230.  
  231.   void LoadOk();
  232.  
  233.   char path[MAXPATHLEN];
  234.   static char altname[MAXPATHLEN] = "\0";
  235.  
  236.   countclick++;
  237.  
  238.   strcpy(path, workdir);
  239.   strcat(path, "/");
  240.   strcat(path, listitem->string);
  241.   XtVaSetValues(text, XtNstring, path, NULL);
  242.  
  243.   if (!(countclick % 2) && (strcmp(altname, listitem->string) == 0))
  244.   {  
  245.     LoadOk(text, (XtPointer) NULL, (XtPointer) NULL);
  246.     countclick = 0;
  247.   }
  248.  
  249.   strcpy(altname, listitem->string);  
  250. }
  251.  
  252. /*************************************************************************/
  253. /* Function Name: LoadOk
  254.  * Description: 
  255.  * Arguments: 
  256.  * Globals: 
  257.  */
  258.  
  259. /* ARGSUSED */
  260. void LoadOk(w, client_data, call_data)
  261. Widget w;
  262. XtPointer client_data, call_data;
  263. {
  264.   Widget popup  = XtParent(XtParent(w));
  265.   Widget button = XtParent(popup);
  266.  
  267.   void update_filelist();
  268.  
  269.   String filename;
  270.   struct stat *buf;
  271.  
  272.   FILE *fp;
  273.  
  274.   char *pal_name;
  275.   XColor farben[NOC];
  276.   int i;
  277.  
  278.   char wert[10];
  279.   char file_zeile[80];
  280.   char *file_gram;
  281.  
  282.   int geslaenge;
  283.   int h;
  284.   char neu[MAXPATHLEN];
  285.   char alt[MAXPATHLEN];
  286.  
  287.  
  288.   countclick = 0;
  289.  
  290.   filename = (char *)malloc(sizeof(char) * MAXPATHLEN);
  291.   if (filename == NULL)
  292.   {
  293.     fprintf(stderr, "Kein Speicher mehr frei!\n");
  294.     fprintf(stderr, "malloc-Aufruf in LoadOk\n");
  295.     exit(1);
  296.   }
  297.  
  298.   XtVaGetValues(text, XtNstring, &filename, NULL);
  299.  
  300.   buf = (struct stat *)malloc(sizeof(struct stat));
  301.   if (buf == NULL)
  302.   {
  303.     fprintf(stderr, "Kein Speicher mehr frei!\n");
  304.     fprintf(stderr, "malloc-Aufruf in LoadOk\n");
  305.     exit(1);
  306.   }
  307.  
  308.   stat(filename, buf);
  309.  
  310.   if (S_ISDIR(buf->st_mode))
  311.   {
  312.     /* Verzeichnis aktualisieren */ 
  313.  
  314.     strcpy(alt, filename);
  315.     geslaenge = strlen(alt);
  316.     if (   (alt[geslaenge-3] == '/')
  317.         && (alt[geslaenge-2] == '.')
  318.         && (alt[geslaenge-1] == '.') )
  319.     {
  320.       geslaenge -= 4;
  321.  
  322.       if (geslaenge > 13) /* wegen /tmp_mnt/home */
  323.       {
  324.         h=0;
  325.         while((alt[geslaenge-h] != '/') && (h < geslaenge))
  326.         {
  327.           h++;
  328.         }
  329.  
  330.         if (geslaenge > h+1)
  331.         {
  332.           geslaenge -= (h+1);
  333.         }
  334.  
  335.         for(h=0; h<=geslaenge; h++)
  336.         {
  337.           neu[h] = alt[h];
  338.         }
  339.         neu[h] = '\0';
  340.         strcpy(workdir, neu);
  341.       }
  342.       else 
  343.       {
  344.         strcpy(workdir, filename);
  345.       }
  346.  
  347.     }
  348.     else
  349.     {
  350.       strcpy(workdir, filename);
  351.     }
  352.  
  353.     XtVaSetValues(text, XtNstring, workdir, NULL);
  354.     update_filelist();
  355.   }
  356.  
  357.   if (S_ISREG(buf->st_mode))
  358.   {
  359.     if ((fp = fopen(filename, "r")) != NULL)
  360.     {
  361.       /* Einlesen der Farb-Palette aus dem File */
  362.       pal_name = (char *)malloc(10 * sizeof(char));
  363.       if (pal_name == NULL)
  364.       {
  365.         fprintf(stderr, "Kein Speicher mehr frei!\n");
  366.         fprintf(stderr, "malloc-Aufruf in LoadOk\n");
  367.         exit(1);
  368.       }
  369.       /* pal_name */
  370.       fscanf(fp, "%s", pal_name);
  371.  
  372.       /* Einlesen der Farbreihenfolge aus dem File */
  373.       for (i=0; i<NOC; i++)
  374.       {
  375.         fscanf(fp, "%s", wert); farben[i].red = atoi(wert);
  376.         fscanf(fp, "%s", wert); farben[i].green = atoi(wert);
  377.         fscanf(fp, "%s", wert); farben[i].blue = atoi(wert);
  378.       }
  379.  
  380.       change_color(pal_name, farben);
  381.  
  382.       free(pal_name);
  383.  
  384.       /* Einlesen der Filedaten in die Turtledaten */
  385.  
  386.       /* g_posx */
  387.       fscanf(fp, "%s", wert);
  388.       XtVaSetValues(g_posx, XtNvalue, wert, NULL);
  389.   
  390.       /* g_posy */
  391.       fscanf(fp, "%s", wert);
  392.       XtVaSetValues(g_posy, XtNvalue, wert, NULL);
  393.   
  394.       /* g_posz */
  395.       fscanf(fp, "%s", wert);
  396.       XtVaSetValues(g_posz, XtNvalue, wert, NULL);
  397.  
  398.       /* g_angle */
  399.       fscanf(fp, "%s", wert); 
  400.       XtVaSetValues(g_angle, XtNvalue, wert, NULL);
  401.   
  402.       /* g_length */
  403.       fscanf(fp, "%s", wert);
  404.       XtVaSetValues(g_length, XtNvalue, wert, NULL);
  405.  
  406.       /* g_scale */
  407.       fscanf(fp, "%s", wert);
  408.       XtVaSetValues(g_scale, XtNvalue, wert, NULL);
  409.  
  410.       /* g_headx */
  411.       fscanf(fp, "%s", wert);
  412.       XtVaSetValues(g_headx, XtNvalue, wert, NULL);
  413.  
  414.       /* g_heady */
  415.       fscanf(fp, "%s", wert);
  416.       XtVaSetValues(g_heady, XtNvalue, wert, NULL);
  417.  
  418.       /* g_headz */
  419.       fscanf(fp, "%s", wert);
  420.       XtVaSetValues(g_headz, XtNvalue, wert, NULL);
  421.  
  422.       /* g_leftx */
  423.       fscanf(fp, "%s", wert);
  424.       XtVaSetValues(g_leftx, XtNvalue, wert, NULL);
  425.   
  426.       /* g_lefty */
  427.       fscanf(fp, "%s", wert);
  428.       XtVaSetValues(g_lefty, XtNvalue, wert, NULL);
  429.  
  430.       /* g_leftz */
  431.       fscanf(fp, "%s", wert);
  432.       XtVaSetValues(g_leftz, XtNvalue, wert, NULL);
  433.  
  434.       /* g_upx */
  435.       fscanf(fp, "%s", wert);
  436.       XtVaSetValues(g_upx, XtNvalue, wert, NULL);
  437.   
  438.       /* g_upy */
  439.       fscanf(fp, "%s", wert);
  440.       XtVaSetValues(g_upy, XtNvalue, wert, NULL);
  441.   
  442.       /* g_upz */
  443.       fscanf(fp, "%s", wert);
  444.       XtVaSetValues(g_upz, XtNvalue, wert, NULL);
  445.  
  446.       /* persp_x0 */
  447.       fscanf(fp, "%s", wert);
  448.       persp_x0 = atoi(wert);
  449.  
  450.       /* persp_y0 */
  451.       fscanf(fp, "%s", wert);
  452.       persp_y0 = atoi(wert);
  453.  
  454.       /* persp_a */
  455.       fscanf(fp, "%s", wert);
  456.       persp_a = atoi(wert);
  457.  
  458.       /* gram */
  459.       file_gram = (char *)calloc(1,sizeof(char)*500);
  460.       if (file_gram == NULL)
  461.       {
  462.         fprintf(stderr, "Kein Speicher mehr frei!\n");
  463.         fprintf(stderr, "calloc-Aufruf in LoadOk\n");
  464.         exit(1);
  465.       }
  466.  
  467.       while (fscanf(fp, "%s", file_zeile) != EOF)
  468.       {
  469.         strcat(file_gram, file_zeile);
  470.         strcat(file_gram, "\n");
  471.       }
  472.       XtVaSetValues(gram, XtNstring, file_gram, NULL);
  473.   
  474.       free(file_gram);
  475.  
  476.       if (fclose(fp))
  477.       {
  478.         fprintf(stderr, "Datei konnte nicht geschlossen werden\n");
  479.         fprintf(stderr, "fclose in LoadOk \n");
  480.         exit(1);
  481.       }
  482.      
  483.       XtSetSensitive(button, TRUE);
  484.       XtDestroyWidget(popup);
  485.     }
  486.   }
  487. }
  488.  
  489. /*************************************************************************/
  490. /* Function Name: LoadCancel
  491.  * Description: 
  492.  * Arguments: 
  493.  */
  494.  
  495. /* ARGSUSED */
  496. void LoadCancel(w, client_data, call_data)
  497. Widget w;
  498. XtPointer client_data, call_data;
  499. {
  500.   Widget popup  = XtParent(XtParent(w));
  501.   Widget button = XtParent(popup);
  502.  
  503.   countclick = 0;
  504.  
  505.   XtSetSensitive(button, TRUE);
  506.   XtDestroyWidget(popup);
  507. }
  508.  
  509. /*************************************************************************/
  510. /*************************************************************************/
  511. /*************************************************************************/
  512. /* Function Name: 
  513.  * Description: 
  514.  * Arguments: 
  515.  * Globals: 
  516.  * Returns: 
  517.  */
  518. /*************************************************************************/
  519.  
  520.